/*
 * Copyright 2018 JDCLOUD.COM
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http:#www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * 云数据库RDS
 * 目前RDS OpenAPI支持云数据库 MySQL、Percona、MariaDB、SQL Server、PostgreSQL
 *
 * OpenAPI spec version: v1
 * Contact: 
 *
 * NOTE: This class is auto generated by the jdcloud code generator program.
 */


using JDCloudSDK.Core.Auth;
using JDCloudSDK.Core.Client;
using JDCloudSDK.Core.Http;
using JDCloudSDK.Rds.Apis;
using JDCloudSDK.Rds.Model;
using System;
using System.Collections.Generic;
using System.Text;
#if NET40||NET35
#else
using System.Threading.Tasks;
#endif

namespace JDCloudSDK.Rds.Client
{
    /// <summary>
    ///  云数据库RDS
    ///  目前RDS OpenAPI支持云数据库 MySQL、Percona、MariaDB、SQL Server、PostgreSQL
    ///  Rds Api 客户端
    ///</summary>
    public class RdsClient : JdcloudClient
    {

        /// <summary>
        ///  默认私有构造函数
        /// </summary>
        private RdsClient()
        {

        }

        /// <summary>
        /// 默认构造函数
        /// </summary>
        /// <param name="credentialsProvider">认证信息</param>
        /// <param name="httpRequestConfig">http 客户端配置信息</param>
        /// <param name="environment">sdk 环境配置信息</param>
        public RdsClient(CredentialsProvider credentialsProvider, HttpRequestConfig httpRequestConfig,SDKEnvironment environment)
        {
            this.httpRequestConfig = httpRequestConfig;
            this.credentialsProvider = credentialsProvider;
            this.environment = environment;
        }

        /// <summary>
        /// 默认构造函数
        /// </summary>
        /// <param name="httpRequestConfig">http 客户端配置信息</param>
        /// <param name="credentialsProvider">认证信息</param>
        public RdsClient(CredentialsProvider credentialsProvider,HttpRequestConfig httpRequestConfig)
        {
            this.httpRequestConfig = httpRequestConfig;
            this.credentialsProvider = credentialsProvider;
        }

        /// <summary>
        /// 默认构造函数，
        /// 注意如果使用此方法 httpRequestConfig 使用的http 请求 schema 为Https
        /// </summary>
        /// <param name="credentialsProvider">认证信息</param>
        public RdsClient(CredentialsProvider credentialsProvider)
        {
            this.credentialsProvider = credentialsProvider;
        }

        /// <summary>
        ///  版本号 1.2.3
        ///</summary>
        public const string ClientVersion = "1.2.3";

        private const string apiVersion = "v1";
        private const string userAgentPrefix = "JdcloudSdkDotNet";
        private const string defaultEndpoint = "rds.jdcloud-api.com";
        private const string serviceName = "rds";
        private const string userAgent = userAgentPrefix + "/" + ClientVersion + " " + serviceName + "/" + apiVersion;


        private SDKEnvironment environment = new SDKEnvironment(defaultEndpoint);
        private CredentialsProvider credentialsProvider;
        private HttpRequestConfig httpRequestConfig;

        /// <summary>
        ///  获取证书信息
        ///</summary>
        public override CredentialsProvider CredentialsProvider   { get { return credentialsProvider; } }

        /// <summary>
        ///  获取http 客户端配置信息
        ///</summary>
        public override HttpRequestConfig HttpRequestConfig { get { return httpRequestConfig; } }

        /// <summary>
        ///  获取sdk环境配置信息
        ///</summary>
        public override SDKEnvironment SDKEnvironment { get { return environment; } }

        /// <summary>
        ///  获取用户自定义浏览器识别字符串
        ///</summary>
        public override string UserAgent { get { return userAgent; } }

        /// <summary>
        ///  获取服务名称
        ///</summary>
        public override string ServiceName { get { return serviceName; } }

        /// <summary>
        ///  获取版本号
        ///</summary>
        public override string Version { get { return apiVersion; } }



#if NET40||NET35
        /// <summary>
        ///  获取某个审计文件的下载链接，同时支持内链和外链，链接的有效时间为24小时&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAuditDownloadURLResponse DescribeAuditDownloadURL(DescribeAuditDownloadURLRequest request) {
            return  new DescribeAuditDownloadURLExecutor().Client(this).Execute<DescribeAuditDownloadURLResponse, DescribeAuditDownloadURLResult, DescribeAuditDownloadURLRequest>(request);
        }
#else
        /// <summary>
        ///  获取某个审计文件的下载链接，同时支持内链和外链，链接的有效时间为24小时&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAuditDownloadURLResponse> DescribeAuditDownloadURL(DescribeAuditDownloadURLRequest request) {
            return await new DescribeAuditDownloadURLExecutor().Client(this).Execute<DescribeAuditDownloadURLResponse, DescribeAuditDownloadURLResult, DescribeAuditDownloadURLRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看开启高安全模式后，当前实例的 SQL 拦截记录&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInterceptResultResponse DescribeInterceptResult(DescribeInterceptResultRequest request) {
            return  new DescribeInterceptResultExecutor().Client(this).Execute<DescribeInterceptResultResponse, DescribeInterceptResultResult, DescribeInterceptResultRequest>(request);
        }
#else
        /// <summary>
        ///  查看开启高安全模式后，当前实例的 SQL 拦截记录&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInterceptResultResponse> DescribeInterceptResult(DescribeInterceptResultRequest request) {
            return await new DescribeInterceptResultExecutor().Client(this).Execute<DescribeInterceptResultResponse, DescribeInterceptResultResult, DescribeInterceptResultRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取整个备份或备份中单个文件的下载链接。&lt;br&gt;- 当输入参数中有文件名时，获取该文件的下载链接。&lt;br&gt;- 输入参数中无文件名时，获取整个备份的下载链接。&lt;br&gt;由于备份机制的差异，使用该接口下载备份时，SQL Server必须输入文件名，每个文件逐一下载，不支持下载整个备份。SQL Server备份中的文件名（不包括后缀）即为备份的数据库名。例如文件名为my_test_db.bak，表示该文件是my_test_db数据库的备份。&lt;br&gt;MySQL可下载整个备份集，但不支持单个文件的下载。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeBackupDownloadURLResponse DescribeBackupDownloadURL(DescribeBackupDownloadURLRequest request) {
            return  new DescribeBackupDownloadURLExecutor().Client(this).Execute<DescribeBackupDownloadURLResponse, DescribeBackupDownloadURLResult, DescribeBackupDownloadURLRequest>(request);
        }
#else
        /// <summary>
        ///  获取整个备份或备份中单个文件的下载链接。&lt;br&gt;- 当输入参数中有文件名时，获取该文件的下载链接。&lt;br&gt;- 输入参数中无文件名时，获取整个备份的下载链接。&lt;br&gt;由于备份机制的差异，使用该接口下载备份时，SQL Server必须输入文件名，每个文件逐一下载，不支持下载整个备份。SQL Server备份中的文件名（不包括后缀）即为备份的数据库名。例如文件名为my_test_db.bak，表示该文件是my_test_db数据库的备份。&lt;br&gt;MySQL可下载整个备份集，但不支持单个文件的下载。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeBackupDownloadURLResponse> DescribeBackupDownloadURL(DescribeBackupDownloadURLRequest request) {
            return await new DescribeBackupDownloadURLExecutor().Client(this).Execute<DescribeBackupDownloadURLResponse, DescribeBackupDownloadURLResult, DescribeBackupDownloadURLRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  拷贝参数组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CopyParameterGroupResponse CopyParameterGroup(CopyParameterGroupRequest request) {
            return  new CopyParameterGroupExecutor().Client(this).Execute<CopyParameterGroupResponse, CopyParameterGroupResult, CopyParameterGroupRequest>(request);
        }
#else
        /// <summary>
        ///  拷贝参数组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CopyParameterGroupResponse> CopyParameterGroup(CopyParameterGroupRequest request) {
            return await new CopyParameterGroupExecutor().Client(this).Execute<CopyParameterGroupResponse, CopyParameterGroupResult, CopyParameterGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  通过 PT-OSC 服务来处理 DDL 命令, 避免锁表。此接口暂是对部分用户开放
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public AlterTableWithOnlineDDLResponse AlterTableWithOnlineDDL(AlterTableWithOnlineDDLRequest request) {
            return  new AlterTableWithOnlineDDLExecutor().Client(this).Execute<AlterTableWithOnlineDDLResponse, AlterTableWithOnlineDDLResult, AlterTableWithOnlineDDLRequest>(request);
        }
#else
        /// <summary>
        ///  通过 PT-OSC 服务来处理 DDL 命令, 避免锁表。此接口暂是对部分用户开放
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<AlterTableWithOnlineDDLResponse> AlterTableWithOnlineDDL(AlterTableWithOnlineDDLRequest request) {
            return await new AlterTableWithOnlineDDLExecutor().Client(this).Execute<AlterTableWithOnlineDDLResponse, AlterTableWithOnlineDDLResult, AlterTableWithOnlineDDLRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改实例的可用区，例如将实例的可用区从单可用区调整为多可用区
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyInstanceAzResponse ModifyInstanceAz(ModifyInstanceAzRequest request) {
            return  new ModifyInstanceAzExecutor().Client(this).Execute<ModifyInstanceAzResponse, ModifyInstanceAzResult, ModifyInstanceAzRequest>(request);
        }
#else
        /// <summary>
        ///  修改实例的可用区，例如将实例的可用区从单可用区调整为多可用区
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyInstanceAzResponse> ModifyInstanceAz(ModifyInstanceAzRequest request) {
            return await new ModifyInstanceAzExecutor().Client(this).Execute<ModifyInstanceAzResponse, ModifyInstanceAzResult, ModifyInstanceAzRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据源实例备份创建一个新实例，并通过追加日志的方式，将新实例的数据恢复到跟源实例指定时间点的数据状态一样。&lt;br&gt;例如根据实例A在“2018-06-18 23:00:00”时间点创建一个实例B，就是新建一个实例B，该实例B的数据跟实例A在“2018-06-18 23:00:00”这个时间点的数据完全一致。&lt;br&gt;对于SQL Server，主备切换后30分钟内，不支持按时间点恢复/创建，例如在10:05分用户进行了主备切换，那么10:05 ~ 10:35这个时间段不能进行按时间点恢复/创建。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateInstanceByTimeResponse CreateInstanceByTime(CreateInstanceByTimeRequest request) {
            return  new CreateInstanceByTimeExecutor().Client(this).Execute<CreateInstanceByTimeResponse, CreateInstanceByTimeResult, CreateInstanceByTimeRequest>(request);
        }
#else
        /// <summary>
        ///  根据源实例备份创建一个新实例，并通过追加日志的方式，将新实例的数据恢复到跟源实例指定时间点的数据状态一样。&lt;br&gt;例如根据实例A在“2018-06-18 23:00:00”时间点创建一个实例B，就是新建一个实例B，该实例B的数据跟实例A在“2018-06-18 23:00:00”这个时间点的数据完全一致。&lt;br&gt;对于SQL Server，主备切换后30分钟内，不支持按时间点恢复/创建，例如在10:05分用户进行了主备切换，那么10:05 ~ 10:35这个时间段不能进行按时间点恢复/创建。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateInstanceByTimeResponse> CreateInstanceByTime(CreateInstanceByTimeRequest request) {
            return await new CreateInstanceByTimeExecutor().Client(this).Execute<CreateInstanceByTimeResponse, CreateInstanceByTimeResult, CreateInstanceByTimeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取当前实例下的所有审计结果文件的列表&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAuditFilesResponse DescribeAuditFiles(DescribeAuditFilesRequest request) {
            return  new DescribeAuditFilesExecutor().Client(this).Execute<DescribeAuditFilesResponse, DescribeAuditFilesResult, DescribeAuditFilesRequest>(request);
        }
#else
        /// <summary>
        ///  获取当前实例下的所有审计结果文件的列表&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAuditFilesResponse> DescribeAuditFiles(DescribeAuditFilesRequest request) {
            return await new DescribeAuditFilesExecutor().Client(this).Execute<DescribeAuditFilesResponse, DescribeAuditFilesResult, DescribeAuditFilesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建数据库账号，用户可以使用客户端，应用程序等通过该账号和密码登录RDS数据库实例。&lt;br&gt;为便于管理和恢复，RDS对账号进行了限制，数据库账号只能通过控制台或者OpenAPI进行创建、删除账号以及对账号授权等，用户不能通过SQL语句对账号进行相关操作。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateAccountResponse CreateAccount(CreateAccountRequest request) {
            return  new CreateAccountExecutor().Client(this).Execute<CreateAccountResponse, CreateAccountResult, CreateAccountRequest>(request);
        }
#else
        /// <summary>
        ///  创建数据库账号，用户可以使用客户端，应用程序等通过该账号和密码登录RDS数据库实例。&lt;br&gt;为便于管理和恢复，RDS对账号进行了限制，数据库账号只能通过控制台或者OpenAPI进行创建、删除账号以及对账号授权等，用户不能通过SQL语句对账号进行相关操作。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateAccountResponse> CreateAccount(CreateAccountRequest request) {
            return await new CreateAccountExecutor().Client(this).Execute<CreateAccountResponse, CreateAccountResult, CreateAccountRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  授予账号的数据库访问权限，即该账号对数据库拥有什么权限。一个账号可以对多个数据库具有访问权限。&lt;br&gt;为便于管理，RDS对权限进行了归类，目前提供以下两种权限&lt;br&gt;- ro：只读权限，用户只能读取数据库中的数据，不能进行创建、插入、删除、更改等操作。&lt;br&gt;- rw：读写权限，用户可以对数据库进行增删改查等操作
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public GrantPrivilegeResponse GrantPrivilege(GrantPrivilegeRequest request) {
            return  new GrantPrivilegeExecutor().Client(this).Execute<GrantPrivilegeResponse, GrantPrivilegeResult, GrantPrivilegeRequest>(request);
        }
#else
        /// <summary>
        ///  授予账号的数据库访问权限，即该账号对数据库拥有什么权限。一个账号可以对多个数据库具有访问权限。&lt;br&gt;为便于管理，RDS对权限进行了归类，目前提供以下两种权限&lt;br&gt;- ro：只读权限，用户只能读取数据库中的数据，不能进行创建、插入、删除、更改等操作。&lt;br&gt;- rw：读写权限，用户可以对数据库进行增删改查等操作
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<GrantPrivilegeResponse> GrantPrivilege(GrantPrivilegeRequest request) {
            return await new GrantPrivilegeExecutor().Client(this).Execute<GrantPrivilegeResponse, GrantPrivilegeResult, GrantPrivilegeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  关闭读写分离代理服务的外网访问功能。关闭后，用户无法通过 Internet 连接读写分离代理服务，但可以在京东云内网通过内网域名连接&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisableReadWriteProxyInternetAccessResponse DisableReadWriteProxyInternetAccess(DisableReadWriteProxyInternetAccessRequest request) {
            return  new DisableReadWriteProxyInternetAccessExecutor().Client(this).Execute<DisableReadWriteProxyInternetAccessResponse, DisableReadWriteProxyInternetAccessResult, DisableReadWriteProxyInternetAccessRequest>(request);
        }
#else
        /// <summary>
        ///  关闭读写分离代理服务的外网访问功能。关闭后，用户无法通过 Internet 连接读写分离代理服务，但可以在京东云内网通过内网域名连接&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisableReadWriteProxyInternetAccessResponse> DisableReadWriteProxyInternetAccess(DisableReadWriteProxyInternetAccessRequest request) {
            return await new DisableReadWriteProxyInternetAccessExecutor().Client(this).Execute<DisableReadWriteProxyInternetAccessResponse, DisableReadWriteProxyInternetAccessResult, DisableReadWriteProxyInternetAccessRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看指定RDS读写分离代理详情&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeReadWriteProxyAttributeResponse DescribeReadWriteProxyAttribute(DescribeReadWriteProxyAttributeRequest request) {
            return  new DescribeReadWriteProxyAttributeExecutor().Client(this).Execute<DescribeReadWriteProxyAttributeResponse, DescribeReadWriteProxyAttributeResult, DescribeReadWriteProxyAttributeRequest>(request);
        }
#else
        /// <summary>
        ///  查看指定RDS读写分离代理详情&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeReadWriteProxyAttributeResponse> DescribeReadWriteProxyAttribute(DescribeReadWriteProxyAttributeRequest request) {
            return await new DescribeReadWriteProxyAttributeExecutor().Client(this).Execute<DescribeReadWriteProxyAttributeResponse, DescribeReadWriteProxyAttributeResult, DescribeReadWriteProxyAttributeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看指定地域下各种RDS数据库支持的可用区，不同类型的RDS支持的可用区不一样
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAzsResponse DescribeAzs(DescribeAzsRequest request) {
            return  new DescribeAzsExecutor().Client(this).Execute<DescribeAzsResponse, DescribeAzsResult, DescribeAzsRequest>(request);
        }
#else
        /// <summary>
        ///  查看指定地域下各种RDS数据库支持的可用区，不同类型的RDS支持的可用区不一样
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAzsResponse> DescribeAzs(DescribeAzsRequest request) {
            return await new DescribeAzsExecutor().Client(this).Execute<DescribeAzsResponse, DescribeAzsResult, DescribeAzsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取单库上云工具上传文件的需要的Key。单库上云工具需要正确的key值方能连接到京东云&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public GetUploadKeyResponse GetUploadKey(GetUploadKeyRequest request) {
            return  new GetUploadKeyExecutor().Client(this).Execute<GetUploadKeyResponse, GetUploadKeyResult, GetUploadKeyRequest>(request);
        }
#else
        /// <summary>
        ///  获取单库上云工具上传文件的需要的Key。单库上云工具需要正确的key值方能连接到京东云&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<GetUploadKeyResponse> GetUploadKey(GetUploadKeyRequest request) {
            return await new GetUploadKeyExecutor().Client(this).Execute<GetUploadKeyResponse, GetUploadKeyResult, GetUploadKeyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  从用户通过单库上云工具上传到云上的备份文件中恢复单个数据库&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RestoreDatabaseFromFileResponse RestoreDatabaseFromFile(RestoreDatabaseFromFileRequest request) {
            return  new RestoreDatabaseFromFileExecutor().Client(this).Execute<RestoreDatabaseFromFileResponse, RestoreDatabaseFromFileResult, RestoreDatabaseFromFileRequest>(request);
        }
#else
        /// <summary>
        ///  从用户通过单库上云工具上传到云上的备份文件中恢复单个数据库&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RestoreDatabaseFromFileResponse> RestoreDatabaseFromFile(RestoreDatabaseFromFileRequest request) {
            return await new RestoreDatabaseFromFileExecutor().Client(this).Execute<RestoreDatabaseFromFileResponse, RestoreDatabaseFromFileResult, RestoreDatabaseFromFileRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询RDS实例（MySQL、SQL Server等）的详细信息以及MySQL/PostgreSQL只读实例详细信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInstanceAttributesResponse DescribeInstanceAttributes(DescribeInstanceAttributesRequest request) {
            return  new DescribeInstanceAttributesExecutor().Client(this).Execute<DescribeInstanceAttributesResponse, DescribeInstanceAttributesResult, DescribeInstanceAttributesRequest>(request);
        }
#else
        /// <summary>
        ///  查询RDS实例（MySQL、SQL Server等）的详细信息以及MySQL/PostgreSQL只读实例详细信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInstanceAttributesResponse> DescribeInstanceAttributes(DescribeInstanceAttributesRequest request) {
            return await new DescribeInstanceAttributesExecutor().Client(this).Execute<DescribeInstanceAttributesResponse, DescribeInstanceAttributesResult, DescribeInstanceAttributesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  实例扩容，支持升级实例的CPU，内存及磁盘。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyInstanceSpecResponse ModifyInstanceSpec(ModifyInstanceSpecRequest request) {
            return  new ModifyInstanceSpecExecutor().Client(this).Execute<ModifyInstanceSpecResponse, ModifyInstanceSpecResult, ModifyInstanceSpecRequest>(request);
        }
#else
        /// <summary>
        ///  实例扩容，支持升级实例的CPU，内存及磁盘。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyInstanceSpecResponse> ModifyInstanceSpec(ModifyInstanceSpecRequest request) {
            return await new ModifyInstanceSpecExecutor().Client(this).Execute<ModifyInstanceSpecResponse, ModifyInstanceSpecResult, ModifyInstanceSpecRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除一个跨地域备份同步服务。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteBackupSynchronicityResponse DeleteBackupSynchronicity(DeleteBackupSynchronicityRequest request) {
            return  new DeleteBackupSynchronicityExecutor().Client(this).Execute<DeleteBackupSynchronicityResponse, DeleteBackupSynchronicityResult, DeleteBackupSynchronicityRequest>(request);
        }
#else
        /// <summary>
        ///  删除一个跨地域备份同步服务。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteBackupSynchronicityResponse> DeleteBackupSynchronicity(DeleteBackupSynchronicityRequest request) {
            return await new DeleteBackupSynchronicityExecutor().Client(this).Execute<DeleteBackupSynchronicityResponse, DeleteBackupSynchronicityResult, DeleteBackupSynchronicityRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除用户通过单库上云工具上传的数据库备份文件&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteImportFileResponse DeleteImportFile(DeleteImportFileRequest request) {
            return  new DeleteImportFileExecutor().Client(this).Execute<DeleteImportFileResponse, DeleteImportFileResult, DeleteImportFileRequest>(request);
        }
#else
        /// <summary>
        ///  删除用户通过单库上云工具上传的数据库备份文件&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteImportFileResponse> DeleteImportFile(DeleteImportFileRequest request) {
            return await new DeleteImportFileExecutor().Client(this).Execute<DeleteImportFileResponse, DeleteImportFileResult, DeleteImportFileRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改当前的审计选项。当前已有审计选项可以通过describeAudit获得，支持的全部选项可以通过getAuditOptions获得。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyAuditResponse ModifyAudit(ModifyAuditRequest request) {
            return  new ModifyAuditExecutor().Client(this).Execute<ModifyAuditResponse, ModifyAuditResult, ModifyAuditRequest>(request);
        }
#else
        /// <summary>
        ///  修改当前的审计选项。当前已有审计选项可以通过describeAudit获得，支持的全部选项可以通过getAuditOptions获得。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyAuditResponse> ModifyAudit(ModifyAuditRequest request) {
            return await new ModifyAuditExecutor().Client(this).Execute<ModifyAuditResponse, ModifyAuditResult, ModifyAuditRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取SQL Server实例按时间点恢复/创建时，可恢复到的最后的一个时间点&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeLatestRestoreTimeResponse DescribeLatestRestoreTime(DescribeLatestRestoreTimeRequest request) {
            return  new DescribeLatestRestoreTimeExecutor().Client(this).Execute<DescribeLatestRestoreTimeResponse, DescribeLatestRestoreTimeResult, DescribeLatestRestoreTimeRequest>(request);
        }
#else
        /// <summary>
        ///  获取SQL Server实例按时间点恢复/创建时，可恢复到的最后的一个时间点&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeLatestRestoreTimeResponse> DescribeLatestRestoreTime(DescribeLatestRestoreTimeRequest request) {
            return await new DescribeLatestRestoreTimeExecutor().Client(this).Execute<DescribeLatestRestoreTimeResponse, DescribeLatestRestoreTimeResult, DescribeLatestRestoreTimeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取SQL Server 错误日志及下载信息&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeErrorLogsResponse DescribeErrorLogs(DescribeErrorLogsRequest request) {
            return  new DescribeErrorLogsExecutor().Client(this).Execute<DescribeErrorLogsResponse, DescribeErrorLogsResult, DescribeErrorLogsRequest>(request);
        }
#else
        /// <summary>
        ///  获取SQL Server 错误日志及下载信息&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeErrorLogsResponse> DescribeErrorLogs(DescribeErrorLogsRequest request) {
            return await new DescribeErrorLogsExecutor().Client(this).Execute<DescribeErrorLogsResponse, DescribeErrorLogsResult, DescribeErrorLogsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启数据库的TDE功能
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableTdeResponse EnableTde(EnableTdeRequest request) {
            return  new EnableTdeExecutor().Client(this).Execute<EnableTdeResponse, EnableTdeResult, EnableTdeRequest>(request);
        }
#else
        /// <summary>
        ///  开启数据库的TDE功能
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableTdeResponse> EnableTde(EnableTdeRequest request) {
            return await new EnableTdeExecutor().Client(this).Execute<EnableTdeResponse, EnableTdeResult, EnableTdeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据源实例全量备份创建一个新实例，新实例的数据跟源实例在创建备份时的数据状态一样。&lt;br&gt;例如根据源实例A的一个全量备份“mybak”新建一个实例B，该备份是在“‘2018-8-18 03:23:54”创建的。那么新建实例B的数据状态跟实例A‘2018-8-18 03:23:54’的状态一致
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateInstanceFromBackupResponse CreateInstanceFromBackup(CreateInstanceFromBackupRequest request) {
            return  new CreateInstanceFromBackupExecutor().Client(this).Execute<CreateInstanceFromBackupResponse, CreateInstanceFromBackupResult, CreateInstanceFromBackupRequest>(request);
        }
#else
        /// <summary>
        ///  根据源实例全量备份创建一个新实例，新实例的数据跟源实例在创建备份时的数据状态一样。&lt;br&gt;例如根据源实例A的一个全量备份“mybak”新建一个实例B，该备份是在“‘2018-8-18 03:23:54”创建的。那么新建实例B的数据状态跟实例A‘2018-8-18 03:23:54’的状态一致
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateInstanceFromBackupResponse> CreateInstanceFromBackup(CreateInstanceFromBackupRequest request) {
            return await new CreateInstanceFromBackupExecutor().Client(this).Execute<CreateInstanceFromBackupResponse, CreateInstanceFromBackupResult, CreateInstanceFromBackupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看SQL Server实例的配置参数&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeParametersResponse DescribeParameters(DescribeParametersRequest request) {
            return  new DescribeParametersExecutor().Client(this).Execute<DescribeParametersResponse, DescribeParametersResult, DescribeParametersRequest>(request);
        }
#else
        /// <summary>
        ///  查看SQL Server实例的配置参数&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeParametersResponse> DescribeParameters(DescribeParametersRequest request) {
            return await new DescribeParametersExecutor().Client(this).Execute<DescribeParametersResponse, DescribeParametersResult, DescribeParametersRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改SQL Server实例的配置参数，目前支持以下参数:max_worker_threads,max_degree_of_parallelism,max_server_memory_(MB)。 部分参数修改后，需要重启才能生效，具体可以参考微软的相关文档。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyParametersResponse ModifyParameters(ModifyParametersRequest request) {
            return  new ModifyParametersExecutor().Client(this).Execute<ModifyParametersResponse, ModifyParametersResult, ModifyParametersRequest>(request);
        }
#else
        /// <summary>
        ///  修改SQL Server实例的配置参数，目前支持以下参数:max_worker_threads,max_degree_of_parallelism,max_server_memory_(MB)。 部分参数修改后，需要重启才能生效，具体可以参考微软的相关文档。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyParametersResponse> ModifyParameters(ModifyParametersRequest request) {
            return await new ModifyParametersExecutor().Client(this).Execute<ModifyParametersResponse, ModifyParametersResult, ModifyParametersRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置日志文件的下载链接过期时间，重新生成 PostgreSQL 的日志文件下载地址
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public UpdateLogDownloadURLInternalResponse UpdateLogDownloadURLInternal(UpdateLogDownloadURLInternalRequest request) {
            return  new UpdateLogDownloadURLInternalExecutor().Client(this).Execute<UpdateLogDownloadURLInternalResponse, UpdateLogDownloadURLInternalResult, UpdateLogDownloadURLInternalRequest>(request);
        }
#else
        /// <summary>
        ///  设置日志文件的下载链接过期时间，重新生成 PostgreSQL 的日志文件下载地址
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<UpdateLogDownloadURLInternalResponse> UpdateLogDownloadURLInternal(UpdateLogDownloadURLInternalRequest request) {
            return await new UpdateLogDownloadURLInternalExecutor().Client(this).Execute<UpdateLogDownloadURLInternalResponse, UpdateLogDownloadURLInternalResult, UpdateLogDownloadURLInternalRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据日志文件的下载链接过期时间，生成日志文件下载地址 仅支持 PostgreSQL, MySQL, Percona, MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeLogDownloadURLResponse DescribeLogDownloadURL(DescribeLogDownloadURLRequest request) {
            return  new DescribeLogDownloadURLExecutor().Client(this).Execute<DescribeLogDownloadURLResponse, DescribeLogDownloadURLResult, DescribeLogDownloadURLRequest>(request);
        }
#else
        /// <summary>
        ///  根据日志文件的下载链接过期时间，生成日志文件下载地址 仅支持 PostgreSQL, MySQL, Percona, MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeLogDownloadURLResponse> DescribeLogDownloadURL(DescribeLogDownloadURLRequest request) {
            return await new DescribeLogDownloadURLExecutor().Client(this).Execute<DescribeLogDownloadURLResponse, DescribeLogDownloadURLResult, DescribeLogDownloadURLRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询PostgreSQL实例的错误日志的概要信息。&lt;br&gt;- 仅支持PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeErrorLogResponse DescribeErrorLog(DescribeErrorLogRequest request) {
            return  new DescribeErrorLogExecutor().Client(this).Execute<DescribeErrorLogResponse, DescribeErrorLogResult, DescribeErrorLogRequest>(request);
        }
#else
        /// <summary>
        ///  查询PostgreSQL实例的错误日志的概要信息。&lt;br&gt;- 仅支持PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeErrorLogResponse> DescribeErrorLog(DescribeErrorLogRequest request) {
            return await new DescribeErrorLogExecutor().Client(this).Execute<DescribeErrorLogResponse, DescribeErrorLogResult, DescribeErrorLogRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  交换两个实例的域名，包括内网域名和外网域名。如果一个实例有外网域名，一个没有，则不允许交换。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ExchangeInstanceDnsResponse ExchangeInstanceDns(ExchangeInstanceDnsRequest request) {
            return  new ExchangeInstanceDnsExecutor().Client(this).Execute<ExchangeInstanceDnsResponse, ExchangeInstanceDnsResult, ExchangeInstanceDnsRequest>(request);
        }
#else
        /// <summary>
        ///  交换两个实例的域名，包括内网域名和外网域名。如果一个实例有外网域名，一个没有，则不允许交换。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ExchangeInstanceDnsResponse> ExchangeInstanceDns(ExchangeInstanceDnsRequest request) {
            return await new ExchangeInstanceDnsExecutor().Client(this).Execute<ExchangeInstanceDnsResponse, ExchangeInstanceDnsResult, ExchangeInstanceDnsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  关闭数据库的高安全模式&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisableInterceptResponse DisableIntercept(DisableInterceptRequest request) {
            return  new DisableInterceptExecutor().Client(this).Execute<DisableInterceptResponse, DisableInterceptResult, DisableInterceptRequest>(request);
        }
#else
        /// <summary>
        ///  关闭数据库的高安全模式&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisableInterceptResponse> DisableIntercept(DisableInterceptRequest request) {
            return await new DisableInterceptExecutor().Client(this).Execute<DisableInterceptResponse, DisableInterceptResult, DisableInterceptRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  仅支持MySQL实例关闭数据库审计&lt;br&gt;- 仅支持 MySQL 5.6, MySQL 5.7, Percona, MariaDB, PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisableAuditResponse DisableAudit(DisableAuditRequest request) {
            return  new DisableAuditExecutor().Client(this).Execute<DisableAuditResponse, DisableAuditResult, DisableAuditRequest>(request);
        }
#else
        /// <summary>
        ///  仅支持MySQL实例关闭数据库审计&lt;br&gt;- 仅支持 MySQL 5.6, MySQL 5.7, Percona, MariaDB, PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisableAuditResponse> DisableAudit(DisableAuditRequest request) {
            return await new DisableAuditExecutor().Client(this).Execute<DisableAuditResponse, DisableAuditResult, DisableAuditRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建一个数据库。 为了实例的管理和数据恢复，RDS对用户权限进行了限制，用户仅能通过控制台或本接口创建数据库
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateDatabaseResponse CreateDatabase(CreateDatabaseRequest request) {
            return  new CreateDatabaseExecutor().Client(this).Execute<CreateDatabaseResponse, CreateDatabaseResult, CreateDatabaseRequest>(request);
        }
#else
        /// <summary>
        ///  创建一个数据库。 为了实例的管理和数据恢复，RDS对用户权限进行了限制，用户仅能通过控制台或本接口创建数据库
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateDatabaseResponse> CreateDatabase(CreateDatabaseRequest request) {
            return await new CreateDatabaseExecutor().Client(this).Execute<CreateDatabaseResponse, CreateDatabaseResult, CreateDatabaseRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置或取消上传文件是否共享给同一账号下的其他实例。缺省情况下，文件仅在上传的实例上可见并可导入，其他实例不可见不可导入。如果需要该文件在其他实例上也可导入，可将此文件设置为共享&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetImportFileSharedResponse SetImportFileShared(SetImportFileSharedRequest request) {
            return  new SetImportFileSharedExecutor().Client(this).Execute<SetImportFileSharedResponse, SetImportFileSharedResult, SetImportFileSharedRequest>(request);
        }
#else
        /// <summary>
        ///  设置或取消上传文件是否共享给同一账号下的其他实例。缺省情况下，文件仅在上传的实例上可见并可导入，其他实例不可见不可导入。如果需要该文件在其他实例上也可导入，可将此文件设置为共享&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetImportFileSharedResponse> SetImportFileShared(SetImportFileSharedRequest request) {
            return await new SetImportFileSharedExecutor().Client(this).Execute<SetImportFileSharedResponse, SetImportFileSharedResult, SetImportFileSharedRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取当前实例的所有数据库详细信息的列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeDatabasesResponse DescribeDatabases(DescribeDatabasesRequest request) {
            return  new DescribeDatabasesExecutor().Client(this).Execute<DescribeDatabasesResponse, DescribeDatabasesResult, DescribeDatabasesRequest>(request);
        }
#else
        /// <summary>
        ///  获取当前实例的所有数据库详细信息的列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeDatabasesResponse> DescribeDatabases(DescribeDatabasesRequest request) {
            return await new DescribeDatabasesExecutor().Client(this).Execute<DescribeDatabasesResponse, DescribeDatabasesResult, DescribeDatabasesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启数据库的加密连接, 同时会重启数据库实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableSSLResponse EnableSSL(EnableSSLRequest request) {
            return  new EnableSSLExecutor().Client(this).Execute<EnableSSLResponse, EnableSSLResult, EnableSSLRequest>(request);
        }
#else
        /// <summary>
        ///  开启数据库的加密连接, 同时会重启数据库实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableSSLResponse> EnableSSL(EnableSSLRequest request) {
            return await new EnableSSLExecutor().Client(this).Execute<EnableSSLResponse, EnableSSLResult, EnableSSLRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据用户定义的查询条件，获取索引性能的统计信息，并提供缺失索引及索引创建建议。用户可以根据这些信息查找与索引相关的性能瓶颈，并进行优化。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeIndexPerformanceResponse DescribeIndexPerformance(DescribeIndexPerformanceRequest request) {
            return  new DescribeIndexPerformanceExecutor().Client(this).Execute<DescribeIndexPerformanceResponse, DescribeIndexPerformanceResult, DescribeIndexPerformanceRequest>(request);
        }
#else
        /// <summary>
        ///  根据用户定义的查询条件，获取索引性能的统计信息，并提供缺失索引及索引创建建议。用户可以根据这些信息查找与索引相关的性能瓶颈，并进行优化。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeIndexPerformanceResponse> DescribeIndexPerformance(DescribeIndexPerformanceRequest request) {
            return await new DescribeIndexPerformanceExecutor().Client(this).Execute<DescribeIndexPerformanceResponse, DescribeIndexPerformanceResult, DescribeIndexPerformanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看RDS实例的账号的权限信息 - 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAccountPrivilegeResponse DescribeAccountPrivilege(DescribeAccountPrivilegeRequest request) {
            return  new DescribeAccountPrivilegeExecutor().Client(this).Execute<DescribeAccountPrivilegeResponse, DescribeAccountPrivilegeResult, DescribeAccountPrivilegeRequest>(request);
        }
#else
        /// <summary>
        ///  查看RDS实例的账号的权限信息 - 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAccountPrivilegeResponse> DescribeAccountPrivilege(DescribeAccountPrivilegeRequest request) {
            return await new DescribeAccountPrivilegeExecutor().Client(this).Execute<DescribeAccountPrivilegeResponse, DescribeAccountPrivilegeResult, DescribeAccountPrivilegeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启SQL Server的数据库审计功能，目前支持实例级的数据库审计。用户可以根据需要开启、关闭审计、自定义审计策略，并下载审计文件。审计文件为原生的SQL Server审计文件，缺省保存6个月。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateAuditResponse CreateAudit(CreateAuditRequest request) {
            return  new CreateAuditExecutor().Client(this).Execute<CreateAuditResponse, CreateAuditResult, CreateAuditRequest>(request);
        }
#else
        /// <summary>
        ///  开启SQL Server的数据库审计功能，目前支持实例级的数据库审计。用户可以根据需要开启、关闭审计、自定义审计策略，并下载审计文件。审计文件为原生的SQL Server审计文件，缺省保存6个月。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateAuditResponse> CreateAudit(CreateAuditRequest request) {
            return await new CreateAuditExecutor().Client(this).Execute<CreateAuditResponse, CreateAuditResult, CreateAuditRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改实例名称，可支持中文，实例名的具体规则可参见帮助中心文档:[名称及密码限制](../../../documentation/Database-and-Cache-Service/RDS/Introduction/Restrictions/SQLServer-Restrictions.md)
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyInstanceNameResponse ModifyInstanceName(ModifyInstanceNameRequest request) {
            return  new ModifyInstanceNameExecutor().Client(this).Execute<ModifyInstanceNameResponse, ModifyInstanceNameResult, ModifyInstanceNameRequest>(request);
        }
#else
        /// <summary>
        ///  修改实例名称，可支持中文，实例名的具体规则可参见帮助中心文档:[名称及密码限制](../../../documentation/Database-and-Cache-Service/RDS/Introduction/Restrictions/SQLServer-Restrictions.md)
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyInstanceNameResponse> ModifyInstanceName(ModifyInstanceNameRequest request) {
            return await new ModifyInstanceNameExecutor().Client(this).Execute<ModifyInstanceNameResponse, ModifyInstanceNameResult, ModifyInstanceNameRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除RDS 实例的读写分离代理&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteReadWriteProxyResponse DeleteReadWriteProxy(DeleteReadWriteProxyRequest request) {
            return  new DeleteReadWriteProxyExecutor().Client(this).Execute<DeleteReadWriteProxyResponse, DeleteReadWriteProxyResult, DeleteReadWriteProxyRequest>(request);
        }
#else
        /// <summary>
        ///  删除RDS 实例的读写分离代理&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteReadWriteProxyResponse> DeleteReadWriteProxy(DeleteReadWriteProxyRequest request) {
            return await new DeleteReadWriteProxyExecutor().Client(this).Execute<DeleteReadWriteProxyResponse, DeleteReadWriteProxyResult, DeleteReadWriteProxyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  仅支持MySQL实例开启数据库审计&lt;br&gt;- 仅支持 MySQL 5.6, MySQL 5.7, Percona, MariaDB, PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableAuditResponse EnableAudit(EnableAuditRequest request) {
            return  new EnableAuditExecutor().Client(this).Execute<EnableAuditResponse, EnableAuditResult, EnableAuditRequest>(request);
        }
#else
        /// <summary>
        ///  仅支持MySQL实例开启数据库审计&lt;br&gt;- 仅支持 MySQL 5.6, MySQL 5.7, Percona, MariaDB, PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableAuditResponse> EnableAudit(EnableAuditRequest request) {
            return await new EnableAuditExecutor().Client(this).Execute<EnableAuditResponse, EnableAuditResult, EnableAuditRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启读写分离代理服务的外网访问功能。开启后，用户可以通过 internet 连接读写分离代理服务&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableReadWriteProxyInternetAccessResponse EnableReadWriteProxyInternetAccess(EnableReadWriteProxyInternetAccessRequest request) {
            return  new EnableReadWriteProxyInternetAccessExecutor().Client(this).Execute<EnableReadWriteProxyInternetAccessResponse, EnableReadWriteProxyInternetAccessResult, EnableReadWriteProxyInternetAccessRequest>(request);
        }
#else
        /// <summary>
        ///  开启读写分离代理服务的外网访问功能。开启后，用户可以通过 internet 连接读写分离代理服务&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableReadWriteProxyInternetAccessResponse> EnableReadWriteProxyInternetAccess(EnableReadWriteProxyInternetAccessRequest request) {
            return await new EnableReadWriteProxyInternetAccessExecutor().Client(this).Execute<EnableReadWriteProxyInternetAccessResponse, EnableReadWriteProxyInternetAccessResult, EnableReadWriteProxyInternetAccessRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建一个RDS实例全量备份，可以对整个实例或者部分数据库（仅SQL Server支持）进行全量备份。同一时间点，只能有一个正在运行的备份任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateBackupResponse CreateBackup(CreateBackupRequest request) {
            return  new CreateBackupExecutor().Client(this).Execute<CreateBackupResponse, CreateBackupResult, CreateBackupRequest>(request);
        }
#else
        /// <summary>
        ///  创建一个RDS实例全量备份，可以对整个实例或者部分数据库（仅SQL Server支持）进行全量备份。同一时间点，只能有一个正在运行的备份任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateBackupResponse> CreateBackup(CreateBackupRequest request) {
            return await new CreateBackupExecutor().Client(this).Execute<CreateBackupResponse, CreateBackupResult, CreateBackupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改RDS实例备份策略，目前仅支持用户修改“自动备份开始时间窗口”这个参数，其他参数暂不开放修改
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyBackupPolicyResponse ModifyBackupPolicy(ModifyBackupPolicyRequest request) {
            return  new ModifyBackupPolicyExecutor().Client(this).Execute<ModifyBackupPolicyResponse, ModifyBackupPolicyResult, ModifyBackupPolicyRequest>(request);
        }
#else
        /// <summary>
        ///  修改RDS实例备份策略，目前仅支持用户修改“自动备份开始时间窗口”这个参数，其他参数暂不开放修改
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyBackupPolicyResponse> ModifyBackupPolicy(ModifyBackupPolicyRequest request) {
            return await new ModifyBackupPolicyExecutor().Client(this).Execute<ModifyBackupPolicyResponse, ModifyBackupPolicyResult, ModifyBackupPolicyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  使用实例的全量备份覆盖恢复当前实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RestoreInstanceResponse RestoreInstance(RestoreInstanceRequest request) {
            return  new RestoreInstanceExecutor().Client(this).Execute<RestoreInstanceResponse, RestoreInstanceResult, RestoreInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  使用实例的全量备份覆盖恢复当前实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RestoreInstanceResponse> RestoreInstance(RestoreInstanceRequest request) {
            return await new RestoreInstanceExecutor().Client(this).Execute<RestoreInstanceResponse, RestoreInstanceResult, RestoreInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取用户通过单库上云工具上传到该实例上的文件列表&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeImportFilesResponse DescribeImportFiles(DescribeImportFilesRequest request) {
            return  new DescribeImportFilesExecutor().Client(this).Execute<DescribeImportFilesResponse, DescribeImportFilesResult, DescribeImportFilesRequest>(request);
        }
#else
        /// <summary>
        ///  获取用户通过单库上云工具上传到该实例上的文件列表&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeImportFilesResponse> DescribeImportFiles(DescribeImportFilesRequest request) {
            return await new DescribeImportFilesExecutor().Client(this).Execute<DescribeImportFilesResponse, DescribeImportFilesResult, DescribeImportFilesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取当前账号下所有的参数组列表&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeParameterGroupsResponse DescribeParameterGroups(DescribeParameterGroupsRequest request) {
            return  new DescribeParameterGroupsExecutor().Client(this).Execute<DescribeParameterGroupsResponse, DescribeParameterGroupsResult, DescribeParameterGroupsRequest>(request);
        }
#else
        /// <summary>
        ///  获取当前账号下所有的参数组列表&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeParameterGroupsResponse> DescribeParameterGroups(DescribeParameterGroupsRequest request) {
            return await new DescribeParameterGroupsExecutor().Client(this).Execute<DescribeParameterGroupsResponse, DescribeParameterGroupsResult, DescribeParameterGroupsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  授予账号的数据库细粒度的访问权限 - 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public GrantAccountPrivilegeResponse GrantAccountPrivilege(GrantAccountPrivilegeRequest request) {
            return  new GrantAccountPrivilegeExecutor().Client(this).Execute<GrantAccountPrivilegeResponse, GrantAccountPrivilegeResult, GrantAccountPrivilegeRequest>(request);
        }
#else
        /// <summary>
        ///  授予账号的数据库细粒度的访问权限 - 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<GrantAccountPrivilegeResponse> GrantAccountPrivilege(GrantAccountPrivilegeRequest request) {
            return await new GrantAccountPrivilegeExecutor().Client(this).Execute<GrantAccountPrivilegeResponse, GrantAccountPrivilegeResult, GrantAccountPrivilegeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  从备份中恢复单个数据库，支持从其他实例（但必须是同一个账号下的实例）备份中恢复。例如可以从生产环境的数据库实例的备份恢复到测试环境的数据库中。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RestoreDatabaseFromBackupResponse RestoreDatabaseFromBackup(RestoreDatabaseFromBackupRequest request) {
            return  new RestoreDatabaseFromBackupExecutor().Client(this).Execute<RestoreDatabaseFromBackupResponse, RestoreDatabaseFromBackupResult, RestoreDatabaseFromBackupRequest>(request);
        }
#else
        /// <summary>
        ///  从备份中恢复单个数据库，支持从其他实例（但必须是同一个账号下的实例）备份中恢复。例如可以从生产环境的数据库实例的备份恢复到测试环境的数据库中。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RestoreDatabaseFromBackupResponse> RestoreDatabaseFromBackup(RestoreDatabaseFromBackupRequest request) {
            return await new RestoreDatabaseFromBackupExecutor().Client(this).Execute<RestoreDatabaseFromBackupResponse, RestoreDatabaseFromBackupResult, RestoreDatabaseFromBackupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建数据库读写分离代理服务&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateReadWriteProxyResponse CreateReadWriteProxy(CreateReadWriteProxyRequest request) {
            return  new CreateReadWriteProxyExecutor().Client(this).Execute<CreateReadWriteProxyResponse, CreateReadWriteProxyResult, CreateReadWriteProxyRequest>(request);
        }
#else
        /// <summary>
        ///  创建数据库读写分离代理服务&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateReadWriteProxyResponse> CreateReadWriteProxy(CreateReadWriteProxyRequest request) {
            return await new CreateReadWriteProxyExecutor().Client(this).Execute<CreateReadWriteProxyResponse, CreateReadWriteProxyResult, CreateReadWriteProxyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看RDS实例当前白名单。白名单是允许访问当前实例的IP/IP段列表，缺省情况下，白名单对本VPC开放。如果用户开启了外网访问的功能，还需要对外网的IP配置白名单。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeWhiteListResponse DescribeWhiteList(DescribeWhiteListRequest request) {
            return  new DescribeWhiteListExecutor().Client(this).Execute<DescribeWhiteListResponse, DescribeWhiteListResult, DescribeWhiteListRequest>(request);
        }
#else
        /// <summary>
        ///  查看RDS实例当前白名单。白名单是允许访问当前实例的IP/IP段列表，缺省情况下，白名单对本VPC开放。如果用户开启了外网访问的功能，还需要对外网的IP配置白名单。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeWhiteListResponse> DescribeWhiteList(DescribeWhiteListRequest request) {
            return await new DescribeWhiteListExecutor().Client(this).Execute<DescribeWhiteListResponse, DescribeWhiteListResult, DescribeWhiteListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  对RDS实例进行主备切换。&lt;br&gt;注意：如果实例正在进行备份，那么主备切换将会终止备份操作。可以查看备份策略中的备份开始时间确认是否有备份正在运行。如果确实需要在实例备份时进行主备切换，建议切换完成 后，手工进行一次实例的全备&lt;br&gt;对于SQL Server，主备切换后30分钟内，不支持按时间点恢复/创建，例如在10:05分用户进行了主备切换，那么10:05 ~ 10:35这个时间段不能进行按时间点恢复/创建。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public FailoverInstanceResponse FailoverInstance(FailoverInstanceRequest request) {
            return  new FailoverInstanceExecutor().Client(this).Execute<FailoverInstanceResponse, FailoverInstanceResult, FailoverInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  对RDS实例进行主备切换。&lt;br&gt;注意：如果实例正在进行备份，那么主备切换将会终止备份操作。可以查看备份策略中的备份开始时间确认是否有备份正在运行。如果确实需要在实例备份时进行主备切换，建议切换完成 后，手工进行一次实例的全备&lt;br&gt;对于SQL Server，主备切换后30分钟内，不支持按时间点恢复/创建，例如在10:05分用户进行了主备切换，那么10:05 ~ 10:35这个时间段不能进行按时间点恢复/创建。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<FailoverInstanceResponse> FailoverInstance(FailoverInstanceRequest request) {
            return await new FailoverInstanceExecutor().Client(this).Execute<FailoverInstanceResponse, FailoverInstanceResult, FailoverInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启增强备份模式，开启后，备份保留天数可大于7天。 免费备份额度外的备份将按照备份占用的空间收费。开启后，不支持关闭。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableEnhancedBackupResponse EnableEnhancedBackup(EnableEnhancedBackupRequest request) {
            return  new EnableEnhancedBackupExecutor().Client(this).Execute<EnableEnhancedBackupResponse, EnableEnhancedBackupResult, EnableEnhancedBackupRequest>(request);
        }
#else
        /// <summary>
        ///  开启增强备份模式，开启后，备份保留天数可大于7天。 免费备份额度外的备份将按照备份占用的空间收费。开启后，不支持关闭。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableEnhancedBackupResponse> EnableEnhancedBackup(EnableEnhancedBackupRequest request) {
            return await new EnableEnhancedBackupExecutor().Client(this).Execute<EnableEnhancedBackupResponse, EnableEnhancedBackupResult, EnableEnhancedBackupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看当前实例已开启的安全模式。如果开启数据库的高安全模式，会返回配置信息&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInterceptResponse DescribeIntercept(DescribeInterceptRequest request) {
            return  new DescribeInterceptExecutor().Client(this).Execute<DescribeInterceptResponse, DescribeInterceptResult, DescribeInterceptRequest>(request);
        }
#else
        /// <summary>
        ///  查看当前实例已开启的安全模式。如果开启数据库的高安全模式，会返回配置信息&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInterceptResponse> DescribeIntercept(DescribeInterceptRequest request) {
            return await new DescribeInterceptExecutor().Client(this).Execute<DescribeInterceptResponse, DescribeInterceptResult, DescribeInterceptRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看云数据库 RDS 的权限信息 - 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribePrivilegeResponse DescribePrivilege(DescribePrivilegeRequest request) {
            return  new DescribePrivilegeExecutor().Client(this).Execute<DescribePrivilegeResponse, DescribePrivilegeResult, DescribePrivilegeRequest>(request);
        }
#else
        /// <summary>
        ///  查看云数据库 RDS 的权限信息 - 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribePrivilegeResponse> DescribePrivilege(DescribePrivilegeRequest request) {
            return await new DescribePrivilegeExecutor().Client(this).Execute<DescribePrivilegeResponse, DescribePrivilegeResult, DescribePrivilegeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  清理本地的binlog并释放空间。 系统只会清理已经备份到存储的binlog，不会影响MySQL实例的备份恢复&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ClearBinlogsResponse ClearBinlogs(ClearBinlogsRequest request) {
            return  new ClearBinlogsExecutor().Client(this).Execute<ClearBinlogsResponse, ClearBinlogsResult, ClearBinlogsRequest>(request);
        }
#else
        /// <summary>
        ///  清理本地的binlog并释放空间。 系统只会清理已经备份到存储的binlog，不会影响MySQL实例的备份恢复&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ClearBinlogsResponse> ClearBinlogs(ClearBinlogsRequest request) {
            return await new ClearBinlogsExecutor().Client(this).Execute<ClearBinlogsResponse, ClearBinlogsResult, ClearBinlogsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看RDS实例备份策略。根据数据库类型的不同，支持的备份策略也略有差异，具体请看返回参数中的详细说明
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeBackupPolicyResponse DescribeBackupPolicy(DescribeBackupPolicyRequest request) {
            return  new DescribeBackupPolicyExecutor().Client(this).Execute<DescribeBackupPolicyResponse, DescribeBackupPolicyResult, DescribeBackupPolicyRequest>(request);
        }
#else
        /// <summary>
        ///  查看RDS实例备份策略。根据数据库类型的不同，支持的备份策略也略有差异，具体请看返回参数中的详细说明
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeBackupPolicyResponse> DescribeBackupPolicy(DescribeBackupPolicyRequest request) {
            return await new DescribeBackupPolicyExecutor().Client(this).Execute<DescribeBackupPolicyResponse, DescribeBackupPolicyResult, DescribeBackupPolicyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取MySQL实例中binlog的详细信息&lt;br&gt;- 仅支持 MySQL, Percona, MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeBinlogsResponse DescribeBinlogs(DescribeBinlogsRequest request) {
            return  new DescribeBinlogsExecutor().Client(this).Execute<DescribeBinlogsResponse, DescribeBinlogsResult, DescribeBinlogsRequest>(request);
        }
#else
        /// <summary>
        ///  获取MySQL实例中binlog的详细信息&lt;br&gt;- 仅支持 MySQL, Percona, MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeBinlogsResponse> DescribeBinlogs(DescribeBinlogsRequest request) {
            return await new DescribeBinlogsExecutor().Client(this).Execute<DescribeBinlogsResponse, DescribeBinlogsResult, DescribeBinlogsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除一个RDS实例或者MySQL/PostgreSQL的只读实例。删除MySQL/PostgreSQL主实例时，会同时将对应的MySQL/PostgreSQL只读实例也删除 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteInstanceResponse DeleteInstance(DeleteInstanceRequest request) {
            return  new DeleteInstanceExecutor().Client(this).Execute<DeleteInstanceResponse, DeleteInstanceResult, DeleteInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  删除一个RDS实例或者MySQL/PostgreSQL的只读实例。删除MySQL/PostgreSQL主实例时，会同时将对应的MySQL/PostgreSQL只读实例也删除 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteInstanceResponse> DeleteInstance(DeleteInstanceRequest request) {
            return await new DeleteInstanceExecutor().Client(this).Execute<DeleteInstanceResponse, DeleteInstanceResult, DeleteInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建一个参数组&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateParameterGroupResponse CreateParameterGroup(CreateParameterGroupRequest request) {
            return  new CreateParameterGroupExecutor().Client(this).Execute<CreateParameterGroupResponse, CreateParameterGroupResult, CreateParameterGroupRequest>(request);
        }
#else
        /// <summary>
        ///  创建一个参数组&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateParameterGroupResponse> CreateParameterGroup(CreateParameterGroupRequest request) {
            return await new CreateParameterGroupExecutor().Client(this).Execute<CreateParameterGroupResponse, CreateParameterGroupResult, CreateParameterGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改数据库临时运维账号属性。&lt;br&gt;- 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyAccountForOpsResponse ModifyAccountForOps(ModifyAccountForOpsRequest request) {
            return  new ModifyAccountForOpsExecutor().Client(this).Execute<ModifyAccountForOpsResponse, ModifyAccountForOpsResult, ModifyAccountForOpsRequest>(request);
        }
#else
        /// <summary>
        ///  修改数据库临时运维账号属性。&lt;br&gt;- 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyAccountForOpsResponse> ModifyAccountForOps(ModifyAccountForOpsRequest request) {
            return await new ModifyAccountForOpsExecutor().Client(this).Execute<ModifyAccountForOpsResponse, ModifyAccountForOpsResult, ModifyAccountForOpsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看该RDS实例下所有备份的详细信息，返回的备份列表按照备份开始时间（backupStartTime）降序排列。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeBackupsResponse DescribeBackups(DescribeBackupsRequest request) {
            return  new DescribeBackupsExecutor().Client(this).Execute<DescribeBackupsResponse, DescribeBackupsResult, DescribeBackupsRequest>(request);
        }
#else
        /// <summary>
        ///  查看该RDS实例下所有备份的详细信息，返回的备份列表按照备份开始时间（backupStartTime）降序排列。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeBackupsResponse> DescribeBackups(DescribeBackupsRequest request) {
            return await new DescribeBackupsExecutor().Client(this).Execute<DescribeBackupsResponse, DescribeBackupsResult, DescribeBackupsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改MySQL实例的连接模式：标准模式(standard) 和高安全模式(security).&lt;br&gt;- **标准模式**：响应时间短，但没有 SQL 审计和拦截的能力。&lt;br&gt;- **高安全模式**：具备一定的 SQL注入拦截能力（通过分析表达式、关键系统函数等来实现防御 SQL 注入攻击），并可开启 SQL 审计，但会增加一定的响应时间。&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyConnectionModeResponse ModifyConnectionMode(ModifyConnectionModeRequest request) {
            return  new ModifyConnectionModeExecutor().Client(this).Execute<ModifyConnectionModeResponse, ModifyConnectionModeResult, ModifyConnectionModeRequest>(request);
        }
#else
        /// <summary>
        ///  修改MySQL实例的连接模式：标准模式(standard) 和高安全模式(security).&lt;br&gt;- **标准模式**：响应时间短，但没有 SQL 审计和拦截的能力。&lt;br&gt;- **高安全模式**：具备一定的 SQL注入拦截能力（通过分析表达式、关键系统函数等来实现防御 SQL 注入攻击），并可开启 SQL 审计，但会增加一定的响应时间。&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyConnectionModeResponse> ModifyConnectionMode(ModifyConnectionModeRequest request) {
            return await new ModifyConnectionModeExecutor().Client(this).Execute<ModifyConnectionModeResponse, ModifyConnectionModeResult, ModifyConnectionModeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  关闭数据库审计。关闭数据库审计后，以前生成的审计结果文件并不会被立即删除。审计结果文件会过期后由系统自动删除，过期时间缺省为6个月&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteAuditResponse DeleteAudit(DeleteAuditRequest request) {
            return  new DeleteAuditExecutor().Client(this).Execute<DeleteAuditResponse, DeleteAuditResult, DeleteAuditRequest>(request);
        }
#else
        /// <summary>
        ///  关闭数据库审计。关闭数据库审计后，以前生成的审计结果文件并不会被立即删除。审计结果文件会过期后由系统自动删除，过期时间缺省为6个月&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteAuditResponse> DeleteAudit(DeleteAuditRequest request) {
            return await new DeleteAuditExecutor().Client(this).Execute<DeleteAuditResponse, DeleteAuditResult, DeleteAuditRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看某个RDS实例下所有账号信息，包括账号名称、对各个数据库的访问权限信息等
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAccountsResponse DescribeAccounts(DescribeAccountsRequest request) {
            return  new DescribeAccountsExecutor().Client(this).Execute<DescribeAccountsResponse, DescribeAccountsResult, DescribeAccountsRequest>(request);
        }
#else
        /// <summary>
        ///  查看某个RDS实例下所有账号信息，包括账号名称、对各个数据库的访问权限信息等
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAccountsResponse> DescribeAccounts(DescribeAccountsRequest request) {
            return await new DescribeAccountsExecutor().Client(this).Execute<DescribeAccountsResponse, DescribeAccountsResult, DescribeAccountsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启RDS实例的外网访问功能。开启后，用户可以通过internet访问RDS实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableInternetAccessResponse EnableInternetAccess(EnableInternetAccessRequest request) {
            return  new EnableInternetAccessExecutor().Client(this).Execute<EnableInternetAccessResponse, EnableInternetAccessResult, EnableInternetAccessRequest>(request);
        }
#else
        /// <summary>
        ///  开启RDS实例的外网访问功能。开启后，用户可以通过internet访问RDS实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableInternetAccessResponse> EnableInternetAccess(EnableInternetAccessRequest request) {
            return await new EnableInternetAccessExecutor().Client(this).Execute<EnableInternetAccessResponse, EnableInternetAccessResult, EnableInternetAccessRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改RDS实例的参数组&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyParameterGroupResponse ModifyParameterGroup(ModifyParameterGroupRequest request) {
            return  new ModifyParameterGroupExecutor().Client(this).Execute<ModifyParameterGroupResponse, ModifyParameterGroupResult, ModifyParameterGroupRequest>(request);
        }
#else
        /// <summary>
        ///  修改RDS实例的参数组&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyParameterGroupResponse> ModifyParameterGroup(ModifyParameterGroupRequest request) {
            return await new ModifyParameterGroupExecutor().Client(this).Execute<ModifyParameterGroupResponse, ModifyParameterGroupResult, ModifyParameterGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看参数的修改历史&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeParameterModifyRecordsResponse DescribeParameterModifyRecords(DescribeParameterModifyRecordsRequest request) {
            return  new DescribeParameterModifyRecordsExecutor().Client(this).Execute<DescribeParameterModifyRecordsResponse, DescribeParameterModifyRecordsResult, DescribeParameterModifyRecordsRequest>(request);
        }
#else
        /// <summary>
        ///  查看参数的修改历史&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeParameterModifyRecordsResponse> DescribeParameterModifyRecords(DescribeParameterModifyRecordsRequest request) {
            return await new DescribeParameterModifyRecordsExecutor().Client(this).Execute<DescribeParameterModifyRecordsResponse, DescribeParameterModifyRecordsResult, DescribeParameterModifyRecordsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取MySQL实例的binlog的下载链接&lt;br&gt;- 仅支持 MySQL, Percona, MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeBinlogDownloadURLResponse DescribeBinlogDownloadURL(DescribeBinlogDownloadURLRequest request) {
            return  new DescribeBinlogDownloadURLExecutor().Client(this).Execute<DescribeBinlogDownloadURLResponse, DescribeBinlogDownloadURLResult, DescribeBinlogDownloadURLRequest>(request);
        }
#else
        /// <summary>
        ///  获取MySQL实例的binlog的下载链接&lt;br&gt;- 仅支持 MySQL, Percona, MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeBinlogDownloadURLResponse> DescribeBinlogDownloadURL(DescribeBinlogDownloadURLRequest request) {
            return await new DescribeBinlogDownloadURLExecutor().Client(this).Execute<DescribeBinlogDownloadURLResponse, DescribeBinlogDownloadURLResult, DescribeBinlogDownloadURLRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取当前实例的指定库的表列表信息 - 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeTablesResponse DescribeTables(DescribeTablesRequest request) {
            return  new DescribeTablesExecutor().Client(this).Execute<DescribeTablesResponse, DescribeTablesResult, DescribeTablesRequest>(request);
        }
#else
        /// <summary>
        ///  获取当前实例的指定库的表列表信息 - 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeTablesResponse> DescribeTables(DescribeTablesRequest request) {
            return await new DescribeTablesExecutor().Client(this).Execute<DescribeTablesResponse, DescribeTablesResult, DescribeTablesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  取消该账号对某个数据库的所有权限。权限取消后，该账号将不能访问此数据库。取消账号对某个数据库的访问权限，不影响该账号对其他数据库的访问权限
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RevokePrivilegeResponse RevokePrivilege(RevokePrivilegeRequest request) {
            return  new RevokePrivilegeExecutor().Client(this).Execute<RevokePrivilegeResponse, RevokePrivilegeResult, RevokePrivilegeRequest>(request);
        }
#else
        /// <summary>
        ///  取消该账号对某个数据库的所有权限。权限取消后，该账号将不能访问此数据库。取消账号对某个数据库的访问权限，不影响该账号对其他数据库的访问权限
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RevokePrivilegeResponse> RevokePrivilege(RevokePrivilegeRequest request) {
            return await new RevokePrivilegeExecutor().Client(this).Execute<RevokePrivilegeResponse, RevokePrivilegeResult, RevokePrivilegeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建数据库临时运维账号。&lt;br&gt;如果在使用数据库过程中需要京东云提供技术支持,并且需要对您的实例进行操作，您可以把临时运维账号提供给技术支持人员。&lt;br&gt;临时运维账号默认授予全局Select、Process权限，且账号只能通过控制台或者OpenAPI进行创建、删除账号以及对账号授权等，用户不能通过SQL语句对账号进行相关操作。&lt;br&gt;- 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateAccountForOpsResponse CreateAccountForOps(CreateAccountForOpsRequest request) {
            return  new CreateAccountForOpsExecutor().Client(this).Execute<CreateAccountForOpsResponse, CreateAccountForOpsResult, CreateAccountForOpsRequest>(request);
        }
#else
        /// <summary>
        ///  创建数据库临时运维账号。&lt;br&gt;如果在使用数据库过程中需要京东云提供技术支持,并且需要对您的实例进行操作，您可以把临时运维账号提供给技术支持人员。&lt;br&gt;临时运维账号默认授予全局Select、Process权限，且账号只能通过控制台或者OpenAPI进行创建、删除账号以及对账号授权等，用户不能通过SQL语句对账号进行相关操作。&lt;br&gt;- 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateAccountForOpsResponse> CreateAccountForOps(CreateAccountForOpsRequest request) {
            return await new CreateAccountForOpsExecutor().Client(this).Execute<CreateAccountForOpsResponse, CreateAccountForOpsResult, CreateAccountForOpsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改SQL Server对接的Active Directory 服务。支持SQL Server 2012 及2012以上以上的版本。&lt;br&gt;注意：修改目录服务后，需重启SQL Server实例才能生效
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyActiveDirectoryResponse ModifyActiveDirectory(ModifyActiveDirectoryRequest request) {
            return  new ModifyActiveDirectoryExecutor().Client(this).Execute<ModifyActiveDirectoryResponse, ModifyActiveDirectoryResult, ModifyActiveDirectoryRequest>(request);
        }
#else
        /// <summary>
        ///  修改SQL Server对接的Active Directory 服务。支持SQL Server 2012 及2012以上以上的版本。&lt;br&gt;注意：修改目录服务后，需重启SQL Server实例才能生效
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyActiveDirectoryResponse> ModifyActiveDirectory(ModifyActiveDirectoryRequest request) {
            return await new ModifyActiveDirectoryExecutor().Client(this).Execute<ModifyActiveDirectoryResponse, ModifyActiveDirectoryResult, ModifyActiveDirectoryRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看当前实例已开启的审计选项。如当前实例未开启审计，则返回空&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAuditResponse DescribeAudit(DescribeAuditRequest request) {
            return  new DescribeAuditExecutor().Client(this).Execute<DescribeAuditResponse, DescribeAuditResult, DescribeAuditRequest>(request);
        }
#else
        /// <summary>
        ///  查看当前实例已开启的审计选项。如当前实例未开启审计，则返回空&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAuditResponse> DescribeAudit(DescribeAuditRequest request) {
            return await new DescribeAuditExecutor().Client(this).Execute<DescribeAuditResponse, DescribeAuditResult, DescribeAuditRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据用户定义的查询条件，获取SQL执行的性能统计信息，例如慢SQL等。用户可以根据这些信息查找与SQL执行相关的性能瓶颈，并进行优化。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeQueryPerformanceResponse DescribeQueryPerformance(DescribeQueryPerformanceRequest request) {
            return  new DescribeQueryPerformanceExecutor().Client(this).Execute<DescribeQueryPerformanceResponse, DescribeQueryPerformanceResult, DescribeQueryPerformanceRequest>(request);
        }
#else
        /// <summary>
        ///  根据用户定义的查询条件，获取SQL执行的性能统计信息，例如慢SQL等。用户可以根据这些信息查找与SQL执行相关的性能瓶颈，并进行优化。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeQueryPerformanceResponse> DescribeQueryPerformance(DescribeQueryPerformanceRequest request) {
            return await new DescribeQueryPerformanceExecutor().Client(this).Execute<DescribeQueryPerformanceResponse, DescribeQueryPerformanceResult, DescribeQueryPerformanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看参数组绑定的云数据库实例&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeParameterGroupAttachedInstancesResponse DescribeParameterGroupAttachedInstances(DescribeParameterGroupAttachedInstancesRequest request) {
            return  new DescribeParameterGroupAttachedInstancesExecutor().Client(this).Execute<DescribeParameterGroupAttachedInstancesResponse, DescribeParameterGroupAttachedInstancesResult, DescribeParameterGroupAttachedInstancesRequest>(request);
        }
#else
        /// <summary>
        ///  查看参数组绑定的云数据库实例&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeParameterGroupAttachedInstancesResponse> DescribeParameterGroupAttachedInstances(DescribeParameterGroupAttachedInstancesRequest request) {
            return await new DescribeParameterGroupAttachedInstancesExecutor().Client(this).Execute<DescribeParameterGroupAttachedInstancesResponse, DescribeParameterGroupAttachedInstancesResult, DescribeParameterGroupAttachedInstancesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看当前实例是否开启TDE
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeTdeResponse DescribeTde(DescribeTdeRequest request) {
            return  new DescribeTdeExecutor().Client(this).Execute<DescribeTdeResponse, DescribeTdeResult, DescribeTdeRequest>(request);
        }
#else
        /// <summary>
        ///  查看当前实例是否开启TDE
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeTdeResponse> DescribeTde(DescribeTdeRequest request) {
            return await new DescribeTdeExecutor().Client(this).Execute<DescribeTdeResponse, DescribeTdeResult, DescribeTdeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建一个跨地域备份同步服务。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateBackupSynchronicityResponse CreateBackupSynchronicity(CreateBackupSynchronicityRequest request) {
            return  new CreateBackupSynchronicityExecutor().Client(this).Execute<CreateBackupSynchronicityResponse, CreateBackupSynchronicityResult, CreateBackupSynchronicityRequest>(request);
        }
#else
        /// <summary>
        ///  创建一个跨地域备份同步服务。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateBackupSynchronicityResponse> CreateBackupSynchronicity(CreateBackupSynchronicityRequest request) {
            return await new CreateBackupSynchronicityExecutor().Client(this).Execute<CreateBackupSynchronicityResponse, CreateBackupSynchronicityResult, CreateBackupSynchronicityRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询MySQL实例的慢日志的详细信息。&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeSlowLogAttributesResponse DescribeSlowLogAttributes(DescribeSlowLogAttributesRequest request) {
            return  new DescribeSlowLogAttributesExecutor().Client(this).Execute<DescribeSlowLogAttributesResponse, DescribeSlowLogAttributesResult, DescribeSlowLogAttributesRequest>(request);
        }
#else
        /// <summary>
        ///  查询MySQL实例的慢日志的详细信息。&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeSlowLogAttributesResponse> DescribeSlowLogAttributes(DescribeSlowLogAttributesRequest request) {
            return await new DescribeSlowLogAttributesExecutor().Client(this).Execute<DescribeSlowLogAttributesResponse, DescribeSlowLogAttributesResult, DescribeSlowLogAttributesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改参数组名称，描述&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyParameterGroupAttributeResponse ModifyParameterGroupAttribute(ModifyParameterGroupAttributeRequest request) {
            return  new ModifyParameterGroupAttributeExecutor().Client(this).Execute<ModifyParameterGroupAttributeResponse, ModifyParameterGroupAttributeResult, ModifyParameterGroupAttributeRequest>(request);
        }
#else
        /// <summary>
        ///  修改参数组名称，描述&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyParameterGroupAttributeResponse> ModifyParameterGroupAttribute(ModifyParameterGroupAttributeRequest request) {
            return await new ModifyParameterGroupAttributeExecutor().Client(this).Execute<ModifyParameterGroupAttributeResponse, ModifyParameterGroupAttributeResult, ModifyParameterGroupAttributeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  仅支持查看MySQL实例的审计内容&lt;br&gt;- 仅支持 MySQL 5.6, MySQL 5.7, Percona, MariaDB, PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAuditResultResponse DescribeAuditResult(DescribeAuditResultRequest request) {
            return  new DescribeAuditResultExecutor().Client(this).Execute<DescribeAuditResultResponse, DescribeAuditResultResult, DescribeAuditResultRequest>(request);
        }
#else
        /// <summary>
        ///  仅支持查看MySQL实例的审计内容&lt;br&gt;- 仅支持 MySQL 5.6, MySQL 5.7, Percona, MariaDB, PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAuditResultResponse> DescribeAuditResult(DescribeAuditResultRequest request) {
            return await new DescribeAuditResultExecutor().Client(this).Execute<DescribeAuditResultResponse, DescribeAuditResultResult, DescribeAuditResultRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询MySQL实例的慢日志的概要信息。&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeSlowLogsResponse DescribeSlowLogs(DescribeSlowLogsRequest request) {
            return  new DescribeSlowLogsExecutor().Client(this).Execute<DescribeSlowLogsResponse, DescribeSlowLogsResult, DescribeSlowLogsRequest>(request);
        }
#else
        /// <summary>
        ///  查询MySQL实例的慢日志的概要信息。&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeSlowLogsResponse> DescribeSlowLogs(DescribeSlowLogsRequest request) {
            return await new DescribeSlowLogsExecutor().Client(this).Execute<DescribeSlowLogsResponse, DescribeSlowLogsResult, DescribeSlowLogsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  从RDS实例中删除数据库。为便于管理和数据恢复，RDS对用户权限进行了控制，用户仅能通过控制台或本接口删除数据库 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteDatabaseResponse DeleteDatabase(DeleteDatabaseRequest request) {
            return  new DeleteDatabaseExecutor().Client(this).Execute<DeleteDatabaseResponse, DeleteDatabaseResult, DeleteDatabaseRequest>(request);
        }
#else
        /// <summary>
        ///  从RDS实例中删除数据库。为便于管理和数据恢复，RDS对用户权限进行了控制，用户仅能通过控制台或本接口删除数据库 [MFA enabled]
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteDatabaseResponse> DeleteDatabase(DeleteDatabaseRequest request) {
            return await new DeleteDatabaseExecutor().Client(this).Execute<DeleteDatabaseResponse, DeleteDatabaseResult, DeleteDatabaseRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据用户定义的查询条件，获取正在执行中的SQL执行的性能信息。用户可以根据这些信息查找与SQL执行相关的性能瓶颈，并进行优化。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeActiveQueryPerformanceResponse DescribeActiveQueryPerformance(DescribeActiveQueryPerformanceRequest request) {
            return  new DescribeActiveQueryPerformanceExecutor().Client(this).Execute<DescribeActiveQueryPerformanceResponse, DescribeActiveQueryPerformanceResult, DescribeActiveQueryPerformanceRequest>(request);
        }
#else
        /// <summary>
        ///  根据用户定义的查询条件，获取正在执行中的SQL执行的性能信息。用户可以根据这些信息查找与SQL执行相关的性能瓶颈，并进行优化。&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeActiveQueryPerformanceResponse> DescribeActiveQueryPerformance(DescribeActiveQueryPerformanceRequest request) {
            return await new DescribeActiveQueryPerformanceExecutor().Client(this).Execute<DescribeActiveQueryPerformanceResponse, DescribeActiveQueryPerformanceResult, DescribeActiveQueryPerformanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建数据库账号，用户可以使用客户端，应用程序等通过该账号和密码登录RDS数据库实例。&lt;br&gt;为便于管理和恢复，RDS对账号进行了限制，数据库账号只能通过控制台或者OpenAPI进行创建、删除账号以及对账号授权等，用户不能通过SQL语句对账号进行相关操作。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateSuperAccountResponse CreateSuperAccount(CreateSuperAccountRequest request) {
            return  new CreateSuperAccountExecutor().Client(this).Execute<CreateSuperAccountResponse, CreateSuperAccountResult, CreateSuperAccountRequest>(request);
        }
#else
        /// <summary>
        ///  创建数据库账号，用户可以使用客户端，应用程序等通过该账号和密码登录RDS数据库实例。&lt;br&gt;为便于管理和恢复，RDS对账号进行了限制，数据库账号只能通过控制台或者OpenAPI进行创建、删除账号以及对账号授权等，用户不能通过SQL语句对账号进行相关操作。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateSuperAccountResponse> CreateSuperAccount(CreateSuperAccountRequest request) {
            return await new CreateSuperAccountExecutor().Client(this).Execute<CreateSuperAccountResponse, CreateSuperAccountResult, CreateSuperAccountRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  重置数据库账号密码。如果用户忘记账号的密码，可以使用该接口重置指定账号密码。密码重置后，以前的密码将无法使用，必须使用重置后的新密码登录或连接数据库实例。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ResetPasswordResponse ResetPassword(ResetPasswordRequest request) {
            return  new ResetPasswordExecutor().Client(this).Execute<ResetPasswordResponse, ResetPasswordResult, ResetPasswordRequest>(request);
        }
#else
        /// <summary>
        ///  重置数据库账号密码。如果用户忘记账号的密码，可以使用该接口重置指定账号密码。密码重置后，以前的密码将无法使用，必须使用重置后的新密码登录或连接数据库实例。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ResetPasswordResponse> ResetPassword(ResetPasswordRequest request) {
            return await new ResetPasswordExecutor().Client(this).Execute<ResetPasswordResponse, ResetPasswordResult, ResetPasswordRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  关闭数据库的加密连接, 需要重启数据库实例才生效&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisableSSLResponse DisableSSL(DisableSSLRequest request) {
            return  new DisableSSLExecutor().Client(this).Execute<DisableSSLResponse, DisableSSLResult, DisableSSLRequest>(request);
        }
#else
        /// <summary>
        ///  关闭数据库的加密连接, 需要重启数据库实例才生效&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisableSSLResponse> DisableSSL(DisableSSLRequest request) {
            return await new DisableSSLExecutor().Client(this).Execute<DisableSSLResponse, DisableSSLResult, DisableSSLRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改允许访问实例的IP白名单。白名单是允许访问当前实例的IP/IP段列表，缺省情况下，白名单对本VPC开放。如果用户开启了外网访问的功能，还需要对外网的IP配置白名单。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyWhiteListResponse ModifyWhiteList(ModifyWhiteListRequest request) {
            return  new ModifyWhiteListExecutor().Client(this).Execute<ModifyWhiteListResponse, ModifyWhiteListResult, ModifyWhiteListRequest>(request);
        }
#else
        /// <summary>
        ///  修改允许访问实例的IP白名单。白名单是允许访问当前实例的IP/IP段列表，缺省情况下，白名单对本VPC开放。如果用户开启了外网访问的功能，还需要对外网的IP配置白名单。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyWhiteListResponse> ModifyWhiteList(ModifyWhiteListRequest request) {
            return await new ModifyWhiteListExecutor().Client(this).Execute<ModifyWhiteListResponse, ModifyWhiteListResult, ModifyWhiteListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启数据库的高安全模式&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableInterceptResponse EnableIntercept(EnableInterceptRequest request) {
            return  new EnableInterceptExecutor().Client(this).Execute<EnableInterceptResponse, EnableInterceptResult, EnableInterceptRequest>(request);
        }
#else
        /// <summary>
        ///  开启数据库的高安全模式&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableInterceptResponse> EnableIntercept(EnableInterceptRequest request) {
            return await new EnableInterceptExecutor().Client(this).Execute<EnableInterceptResponse, EnableInterceptResult, EnableInterceptRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  重启RDS实例，例如修改了一些配置参数后，需要重启实例才能生效。可以结合主备切换的功能，轮流重启备机，降低对业务的影响&lt;br&gt;**注意：如果实例正在进行备份，那么重启主实例将会终止备份操作。** 可以查看备份策略中的备份开始时间确认是否有备份正在运行。如果确实需要在实例备份时重启主实例，建议重启后，手工进行一次实例的全备。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RebootInstanceResponse RebootInstance(RebootInstanceRequest request) {
            return  new RebootInstanceExecutor().Client(this).Execute<RebootInstanceResponse, RebootInstanceResult, RebootInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  重启RDS实例，例如修改了一些配置参数后，需要重启实例才能生效。可以结合主备切换的功能，轮流重启备机，降低对业务的影响&lt;br&gt;**注意：如果实例正在进行备份，那么重启主实例将会终止备份操作。** 可以查看备份策略中的备份开始时间确认是否有备份正在运行。如果确实需要在实例备份时重启主实例，建议重启后，手工进行一次实例的全备。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RebootInstanceResponse> RebootInstance(RebootInstanceRequest request) {
            return await new RebootInstanceExecutor().Client(this).Execute<RebootInstanceResponse, RebootInstanceResult, RebootInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看当前实例已开启加密连接。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeSSLResponse DescribeSSL(DescribeSSLRequest request) {
            return  new DescribeSSLExecutor().Client(this).Execute<DescribeSSLResponse, DescribeSSLResult, DescribeSSLRequest>(request);
        }
#else
        /// <summary>
        ///  查看当前实例已开启加密连接。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeSSLResponse> DescribeSSL(DescribeSSLRequest request) {
            return await new DescribeSSLExecutor().Client(this).Execute<DescribeSSLResponse, DescribeSSLResult, DescribeSSLRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看RDS读写分离代理列表&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeReadWriteProxiesResponse DescribeReadWriteProxies(DescribeReadWriteProxiesRequest request) {
            return  new DescribeReadWriteProxiesExecutor().Client(this).Execute<DescribeReadWriteProxiesResponse, DescribeReadWriteProxiesResult, DescribeReadWriteProxiesRequest>(request);
        }
#else
        /// <summary>
        ///  查看RDS读写分离代理列表&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeReadWriteProxiesResponse> DescribeReadWriteProxies(DescribeReadWriteProxiesRequest request) {
            return await new DescribeReadWriteProxiesExecutor().Client(this).Execute<DescribeReadWriteProxiesResponse, DescribeReadWriteProxiesResult, DescribeReadWriteProxiesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看某个RDS实例下的运维账号信息。&lt;br&gt;- 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAccountsForOpsResponse DescribeAccountsForOps(DescribeAccountsForOpsRequest request) {
            return  new DescribeAccountsForOpsExecutor().Client(this).Execute<DescribeAccountsForOpsResponse, DescribeAccountsForOpsResult, DescribeAccountsForOpsRequest>(request);
        }
#else
        /// <summary>
        ///  查看某个RDS实例下的运维账号信息。&lt;br&gt;- 仅支持 MySQL，Percona，MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAccountsForOpsResponse> DescribeAccountsForOps(DescribeAccountsForOpsRequest request) {
            return await new DescribeAccountsForOpsExecutor().Client(this).Execute<DescribeAccountsForOpsResponse, DescribeAccountsForOpsResult, DescribeAccountsForOpsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询该用户pin关联的备份的计费信息。仅当该用户开启了增强备份后有效。如用户未开启增强备份，返回null&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeBackupChargeResponse DescribeBackupCharge(DescribeBackupChargeRequest request) {
            return  new DescribeBackupChargeExecutor().Client(this).Execute<DescribeBackupChargeResponse, DescribeBackupChargeResult, DescribeBackupChargeRequest>(request);
        }
#else
        /// <summary>
        ///  查询该用户pin关联的备份的计费信息。仅当该用户开启了增强备份后有效。如用户未开启增强备份，返回null&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeBackupChargeResponse> DescribeBackupCharge(DescribeBackupChargeRequest request) {
            return await new DescribeBackupChargeExecutor().Client(this).Execute<DescribeBackupChargeResponse, DescribeBackupChargeResult, DescribeBackupChargeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除参数组&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteParameterGroupResponse DeleteParameterGroup(DeleteParameterGroupRequest request) {
            return  new DeleteParameterGroupExecutor().Client(this).Execute<DeleteParameterGroupResponse, DeleteParameterGroupResult, DeleteParameterGroupRequest>(request);
        }
#else
        /// <summary>
        ///  删除参数组&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteParameterGroupResponse> DeleteParameterGroup(DeleteParameterGroupRequest request) {
            return await new DeleteParameterGroupExecutor().Client(this).Execute<DeleteParameterGroupResponse, DeleteParameterGroupResult, DeleteParameterGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建一个RDS实例，用户可以使用相应的数据库客户端或者应用程序通过域名和端口链接到该RDS实例上，进行操作。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateInstanceResponse CreateInstance(CreateInstanceRequest request) {
            return  new CreateInstanceExecutor().Client(this).Execute<CreateInstanceResponse, CreateInstanceResult, CreateInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  创建一个RDS实例，用户可以使用相应的数据库客户端或者应用程序通过域名和端口链接到该RDS实例上，进行操作。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateInstanceResponse> CreateInstance(CreateInstanceRequest request) {
            return await new CreateInstanceExecutor().Client(this).Execute<CreateInstanceResponse, CreateInstanceResult, CreateInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取日志文件列表&lt;br&gt;- 仅支持PostgreSQL, MySQL, Percona, MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeLogsResponse DescribeLogs(DescribeLogsRequest request) {
            return  new DescribeLogsExecutor().Client(this).Execute<DescribeLogsResponse, DescribeLogsResult, DescribeLogsRequest>(request);
        }
#else
        /// <summary>
        ///  获取日志文件列表&lt;br&gt;- 仅支持PostgreSQL, MySQL, Percona, MariaDB
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeLogsResponse> DescribeLogs(DescribeLogsRequest request) {
            return await new DescribeLogsExecutor().Client(this).Execute<DescribeLogsResponse, DescribeLogsResult, DescribeLogsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  从上传到OSS的备份文件中恢复单个数据库&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RestoreDatabaseFromOSSResponse RestoreDatabaseFromOSS(RestoreDatabaseFromOSSRequest request) {
            return  new RestoreDatabaseFromOSSExecutor().Client(this).Execute<RestoreDatabaseFromOSSResponse, RestoreDatabaseFromOSSResult, RestoreDatabaseFromOSSRequest>(request);
        }
#else
        /// <summary>
        ///  从上传到OSS的备份文件中恢复单个数据库&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RestoreDatabaseFromOSSResponse> RestoreDatabaseFromOSS(RestoreDatabaseFromOSSRequest request) {
            return await new RestoreDatabaseFromOSSExecutor().Client(this).Execute<RestoreDatabaseFromOSSResponse, RestoreDatabaseFromOSSResult, RestoreDatabaseFromOSSRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除RDS实例备份，仅允许删除用户生成的备份，系统自动备份不允许删除。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteBackupResponse DeleteBackup(DeleteBackupRequest request) {
            return  new DeleteBackupExecutor().Client(this).Execute<DeleteBackupResponse, DeleteBackupResult, DeleteBackupRequest>(request);
        }
#else
        /// <summary>
        ///  删除RDS实例备份，仅允许删除用户生成的备份，系统自动备份不允许删除。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteBackupResponse> DeleteBackup(DeleteBackupRequest request) {
            return await new DeleteBackupExecutor().Client(this).Execute<DeleteBackupResponse, DeleteBackupResult, DeleteBackupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询跨地域备份同步服务列表。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeBackupSynchronicitiesResponse DescribeBackupSynchronicities(DescribeBackupSynchronicitiesRequest request) {
            return  new DescribeBackupSynchronicitiesExecutor().Client(this).Execute<DescribeBackupSynchronicitiesResponse, DescribeBackupSynchronicitiesResult, DescribeBackupSynchronicitiesRequest>(request);
        }
#else
        /// <summary>
        ///  查询跨地域备份同步服务列表。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeBackupSynchronicitiesResponse> DescribeBackupSynchronicities(DescribeBackupSynchronicitiesRequest request) {
            return await new DescribeBackupSynchronicitiesExecutor().Client(this).Execute<DescribeBackupSynchronicitiesResponse, DescribeBackupSynchronicitiesResult, DescribeBackupSynchronicitiesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看参数组的参数&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeParameterGroupParametersResponse DescribeParameterGroupParameters(DescribeParameterGroupParametersRequest request) {
            return  new DescribeParameterGroupParametersExecutor().Client(this).Execute<DescribeParameterGroupParametersResponse, DescribeParameterGroupParametersResult, DescribeParameterGroupParametersRequest>(request);
        }
#else
        /// <summary>
        ///  查看参数组的参数&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeParameterGroupParametersResponse> DescribeParameterGroupParameters(DescribeParameterGroupParametersRequest request) {
            return await new DescribeParameterGroupParametersExecutor().Client(this).Execute<DescribeParameterGroupParametersResponse, DescribeParameterGroupParametersResult, DescribeParameterGroupParametersRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  当实例开启增强备份模式后，查询实例备份的空间使用情况&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeBackupSpaceResponse DescribeBackupSpace(DescribeBackupSpaceRequest request) {
            return  new DescribeBackupSpaceExecutor().Client(this).Execute<DescribeBackupSpaceResponse, DescribeBackupSpaceResult, DescribeBackupSpaceRequest>(request);
        }
#else
        /// <summary>
        ///  当实例开启增强备份模式后，查询实例备份的空间使用情况&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeBackupSpaceResponse> DescribeBackupSpace(DescribeBackupSpaceRequest request) {
            return await new DescribeBackupSpaceExecutor().Client(this).Execute<DescribeBackupSpaceResponse, DescribeBackupSpaceResult, DescribeBackupSpaceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改数据库读写分离代理服务配置&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyReadWriteProxyResponse ModifyReadWriteProxy(ModifyReadWriteProxyRequest request) {
            return  new ModifyReadWriteProxyExecutor().Client(this).Execute<ModifyReadWriteProxyResponse, ModifyReadWriteProxyResult, ModifyReadWriteProxyRequest>(request);
        }
#else
        /// <summary>
        ///  修改数据库读写分离代理服务配置&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyReadWriteProxyResponse> ModifyReadWriteProxy(ModifyReadWriteProxyRequest request) {
            return await new ModifyReadWriteProxyExecutor().Client(this).Execute<ModifyReadWriteProxyResponse, ModifyReadWriteProxyResult, ModifyReadWriteProxyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  关闭RDS实例的外网访问功能。关闭后，用户无法通过Internet访问RDS，但可以在京东云内网通过内网域名访问
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisableInternetAccessResponse DisableInternetAccess(DisableInternetAccessRequest request) {
            return  new DisableInternetAccessExecutor().Client(this).Execute<DisableInternetAccessResponse, DisableInternetAccessResult, DisableInternetAccessRequest>(request);
        }
#else
        /// <summary>
        ///  关闭RDS实例的外网访问功能。关闭后，用户无法通过Internet访问RDS，但可以在京东云内网通过内网域名访问
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisableInternetAccessResponse> DisableInternetAccess(DisableInternetAccessRequest request) {
            return await new DisableInternetAccessExecutor().Client(this).Execute<DisableInternetAccessResponse, DisableInternetAccessResult, DisableInternetAccessRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取当前账号下所有RDS实例及MySQL/PostgreSQL只读实例的概要信息，例如实例类型，版本，计费信息等
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeInstancesResponse DescribeInstances(DescribeInstancesRequest request) {
            return  new DescribeInstancesExecutor().Client(this).Execute<DescribeInstancesResponse, DescribeInstancesResult, DescribeInstancesRequest>(request);
        }
#else
        /// <summary>
        ///  获取当前账号下所有RDS实例及MySQL/PostgreSQL只读实例的概要信息，例如实例类型，版本，计费信息等
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeInstancesResponse> DescribeInstances(DescribeInstancesRequest request) {
            return await new DescribeInstancesExecutor().Client(this).Execute<DescribeInstancesResponse, DescribeInstancesResult, DescribeInstancesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建MySQL的只读实例&lt;br&gt; - 仅支持MySQL&lt;br&gt; - 创建的只读实例跟主实例在同一个VPC同一个子网中&lt;br&gt; * 只读实例只支持按配置计费
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateROInstanceResponse CreateROInstance(CreateROInstanceRequest request) {
            return  new CreateROInstanceExecutor().Client(this).Execute<CreateROInstanceResponse, CreateROInstanceResult, CreateROInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  创建MySQL的只读实例&lt;br&gt; - 仅支持MySQL&lt;br&gt; - 创建的只读实例跟主实例在同一个VPC同一个子网中&lt;br&gt; * 只读实例只支持按配置计费
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateROInstanceResponse> CreateROInstance(CreateROInstanceRequest request) {
            return await new CreateROInstanceExecutor().Client(this).Execute<CreateROInstanceResponse, CreateROInstanceResult, CreateROInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取当前系统所支持的各种数据库版本的审计选项及相应的推荐选项&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DescribeAuditOptionsResponse DescribeAuditOptions(DescribeAuditOptionsRequest request) {
            return  new DescribeAuditOptionsExecutor().Client(this).Execute<DescribeAuditOptionsResponse, DescribeAuditOptionsResult, DescribeAuditOptionsRequest>(request);
        }
#else
        /// <summary>
        ///  获取当前系统所支持的各种数据库版本的审计选项及相应的推荐选项&lt;br&gt;- 仅支持SQL Server
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DescribeAuditOptionsResponse> DescribeAuditOptions(DescribeAuditOptionsRequest request) {
            return await new DescribeAuditOptionsExecutor().Client(this).Execute<DescribeAuditOptionsResponse, DescribeAuditOptionsResult, DescribeAuditOptionsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除数据库账号，账号删除后不可恢复，用户无法再使用该账号登录RDS实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteAccountResponse DeleteAccount(DeleteAccountRequest request) {
            return  new DeleteAccountExecutor().Client(this).Execute<DeleteAccountResponse, DeleteAccountResult, DeleteAccountRequest>(request);
        }
#else
        /// <summary>
        ///  删除数据库账号，账号删除后不可恢复，用户无法再使用该账号登录RDS实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteAccountResponse> DeleteAccount(DeleteAccountRequest request) {
            return await new DeleteAccountExecutor().Client(this).Execute<DeleteAccountResponse, DeleteAccountResult, DeleteAccountRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改参数组的参数&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyParameterGroupParametersResponse ModifyParameterGroupParameters(ModifyParameterGroupParametersRequest request) {
            return  new ModifyParameterGroupParametersExecutor().Client(this).Execute<ModifyParameterGroupParametersResponse, ModifyParameterGroupParametersResult, ModifyParameterGroupParametersRequest>(request);
        }
#else
        /// <summary>
        ///  修改参数组的参数&lt;br&gt;- 仅支持MySQL，Percona，MariaDB，PostgreSQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyParameterGroupParametersResponse> ModifyParameterGroupParameters(ModifyParameterGroupParametersRequest request) {
            return await new ModifyParameterGroupParametersExecutor().Client(this).Execute<ModifyParameterGroupParametersResponse, ModifyParameterGroupParametersResult, ModifyParameterGroupParametersRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据跨地域备份同步服务时间点创建实例。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateInstanceByTimeInCrossRegionResponse CreateInstanceByTimeInCrossRegion(CreateInstanceByTimeInCrossRegionRequest request) {
            return  new CreateInstanceByTimeInCrossRegionExecutor().Client(this).Execute<CreateInstanceByTimeInCrossRegionResponse, CreateInstanceByTimeInCrossRegionResult, CreateInstanceByTimeInCrossRegionRequest>(request);
        }
#else
        /// <summary>
        ///  根据跨地域备份同步服务时间点创建实例。
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateInstanceByTimeInCrossRegionResponse> CreateInstanceByTimeInCrossRegion(CreateInstanceByTimeInCrossRegionRequest request) {
            return await new CreateInstanceByTimeInCrossRegionExecutor().Client(this).Execute<CreateInstanceByTimeInCrossRegionResponse, CreateInstanceByTimeInCrossRegionResult, CreateInstanceByTimeInCrossRegionRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据时间点，选择单表恢复当前实例&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public RestoreInstanceByTimeResponse RestoreInstanceByTime(RestoreInstanceByTimeRequest request) {
            return  new RestoreInstanceByTimeExecutor().Client(this).Execute<RestoreInstanceByTimeResponse, RestoreInstanceByTimeResult, RestoreInstanceByTimeRequest>(request);
        }
#else
        /// <summary>
        ///  根据时间点，选择单表恢复当前实例&lt;br&gt;- 仅支持MySQL
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<RestoreInstanceByTimeResponse> RestoreInstanceByTime(RestoreInstanceByTimeRequest request) {
            return await new RestoreInstanceByTimeExecutor().Client(this).Execute<RestoreInstanceByTimeResponse, RestoreInstanceByTimeResult, RestoreInstanceByTimeRequest>(request).ConfigureAwait(false);
        }
#endif

            /// <summary>
            ///  默认RdsClient 构造器 接口
            ///</summary>
            public interface Builder
            {

                /// <summary>
                /// 设置认证信息参数
                /// </summary>
                /// <param name="provider">认证信息提供对象</param>
                /// <returns>rdsClient 构造器</returns>
                Builder CredentialsProvider(CredentialsProvider provider);

                /// <summary>
                /// 设置请求环境参数
                /// </summary>
                /// <param name="environment">环境参数信息</param>
                /// <returns>rdsClient 构造器</returns>
                Builder Environment(Core.Client.SDKEnvironment environment);

                /// <summary>
                /// http 请求配置信息
                /// </summary>
                /// <param name="config">http 请求配置信息</param>
                /// <returns>rdsClient 构造器</returns>
                Builder HttpRequestConfig(HttpRequestConfig config);

                /// <summary>
                ///  构造RdsClient 对象
                ///</summary>
                RdsClient Build();
            }

            /// <summary>
            ///  默认RdsClient 构造器
            ///</summary>
            public class DefaultBuilder : Builder
            {
                /// <summary>
                ///  RdsClient service client
                /// </summary>
                private  RdsClient rdsClient;

                /// <summary>
                ///  默认RdsClient 构造器构造对象
                ///</summary>
                public DefaultBuilder()
                {
                    rdsClient = new RdsClient();
                }

                /// <summary>
                ///  构造RdsClient 对象
                ///</summary>
                public RdsClient Build()
                {
                    if (rdsClient.CredentialsProvider == null)
                    {
                        //if credentialsProvider not set, try load jdcloud global default  credentials provider
                        rdsClient.credentialsProvider = JdCloud.DefaultInstance.GetCredentialsProvider();
                        if (rdsClient.credentialsProvider == null)
                        {
                            throw new ArgumentNullException("RdsClient build error: jdcloud credentials provider not set");
                        }
                    }
                    if (rdsClient.HttpRequestConfig == null)
                    {
                        rdsClient.httpRequestConfig = JdCloud.DefaultInstance.GetHttpRequestConfig();
                        if (rdsClient.httpRequestConfig == null)
                        {
                        throw new ArgumentNullException("RdsClient build error: http request config not set");
                        }
                    }
                    return rdsClient;
                }

                /// <summary>
                /// 设置认证信息参数
                /// </summary>
                /// <param name="provider">认证信息提供对象</param>
                /// <returns>rdsClient 构造器</returns>
                public Builder CredentialsProvider(CredentialsProvider provider)
                {
                    rdsClient.credentialsProvider = provider;
                    return this;
                }

                /// <summary>
                /// 设置请求环境参数
                /// </summary>
                /// <param name="environment">环境参数信息</param>
                /// <returns>rdsClient 构造器</returns>
                public Builder Environment(SDKEnvironment environment)
                {
                    rdsClient.environment = environment;
                    return this;
                }

                /// <summary>
                /// http 请求配置信息
                /// </summary>
                /// <param name="config">http 请求配置信息</param>
                /// <returns>rdsClient 构造器</returns>
                public Builder HttpRequestConfig(HttpRequestConfig config)
                {
                    rdsClient.httpRequestConfig = config;
                    return this;
                }
            }
    }
}
